Feature Volatility Assessment

With the development of new modularization techniques, such as aspect-oriented programming and feature-oriented programming, assessing and comparing their differences in different circumstances becomes important for the user to chose, compare and synthesize these techniques. Numerous studies have been conducted to assess and compare different software modularization techniques in terms of their impact on software modularity and stability when new features are added [3][4][5]. At the same time, it has been realized that traditional software metrics based on coupling and cohesion measurement are not effective in terms of measuring key properties of modularity, such as separation of concerns and option value generation. Researchers have proposed and applied new assessment techniques. Concern-based metrics, such as Concern Diffusion over Components (CDC), Concern Diffusion over Operations (CDO), Concern Diffusion over Lines of Code (CDLOC), have been used to compare aspect-oriented vs. object-oriented implementations[3][4][6]. Baldwin and Clark’s net option value analysis and design structure matrix modeling [1] have been used to assess how well different paradigms can effectively generate option values [2][6][8]. These studies show that the impact of a modularization technique not only depends on the techniques itself, but also depends on the design and nature of a particular feature. For example, some modularization techniques make crosscutting features more stable, such as exception handling, while making other types of features more volatile. It is also possible that these modularization techniques do not make much difference for certain types of features. The concern-based metrics only count the number of components, operation, and lines of code that are influenced by the feature, but do not directly assess how stable these components are. The option-based metrics measure the effects of overall design, blurring the impact on each feature. In the paper, we propose a feature stability/volatility measurement to explicitly show which modularization technique is the best for which type of features, and to show how the stability of each feature changes over time. Using these feature stability measurements, the designer can not only compare and contrast different modularization techniques, but also track which features is most volatile or how maintenance activities change feature volatility over time. For a highly volatile feature, the components implementing it will be changed frequently. Our idea is to combine concern diffusion measurement with the internal coupling of components. The rationale is that: feature stability depends on the stability of the components that implements the feature, and the stability of the feature is thus the summation of the stability of its components. As a result, we first need to measure the stability of each component. Traditionally, the stability of a software component is measured by the number of dependents (fan-out dependencies) divided by the total number of dependencies (both fan-in and fan-out). That is, the more dependents a component has and the fewer it depends on, the more stable a component is. However, it is possible that all the other components a component depends on are stable in the sense that they do not subject to any environmental changes. Based on the assumption that environmental factors, such as features, are the drivers of software changes, our recent work [6] proposed a new software volatility measure: the more features influence a components (EnvrImpact), and the more dependents it has (ImpactScope), the more volatile it is. That is, for component i, Volatiltyi= EnvrImpacti* ImpactScopei. Accordingly, the volatility of a feature is the summation volatility of each component implementing it: FeatureVolatilty = Volatilityi.